using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("FriendChallengeMgr")]
	public class FriendChallengeMgr : MonoClass
	{
		public enum DeclineReason
		{
			None,
			UserDeclined,
			NoValidDeck,
			StandardNoValidDeck,
			TavernBrawlNoValidDeck,
			TavernBrawlNotUnlocked,
			UserIsBusy,
			NotSeenWild
		}

		public static int DEFAULT_SCENARIO_ID => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "DEFAULT_SCENARIO_ID");

		public static bool FRIENDLY_CHALLENGE_PARTY_INVITES_USE_RESERVATIONS => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "FRIENDLY_CHALLENGE_PARTY_INVITES_USE_RESERVATIONS");

		public bool m_netCacheReady => method_2<bool>("m_netCacheReady");

		public bool m_myPlayerReady => method_2<bool>("m_myPlayerReady");

		public bool m_challengerPending => method_2<bool>("m_challengerPending");

		public int m_scenarioId => method_2<int>("m_scenarioId");

		public int m_seasonId => method_2<int>("m_seasonId");

		public BrawlType m_challengeBrawlType => method_2<BrawlType>("m_challengeBrawlType");

		public BnetPlayer m_challenger => method_3<BnetPlayer>("m_challenger");

		public long m_challengerDeckId => method_2<long>("m_challengerDeckId");

		public long m_challengerHeroId => method_2<long>("m_challengerHeroId");

		public bool m_challengerDeckOrHeroSelected => method_2<bool>("m_challengerDeckOrHeroSelected");

		public List<byte> m_challengerFsgSharedSecret => method_3<Class250<byte>>("m_challengerFsgSharedSecret")?.method_25();

		public BnetPlayer m_challengee => method_3<BnetPlayer>("m_challengee");

		public long m_challengeeDeckId => method_2<long>("m_challengeeDeckId");

		public long m_challengeeHeroId => method_2<long>("m_challengeeHeroId");

		public List<byte> m_challengeeFsgSharedSecret => method_3<Class250<byte>>("m_challengeeFsgSharedSecret")?.method_25();

		public bool m_challengeeAccepted => method_2<bool>("m_challengeeAccepted");

		public bool m_challengeeDeckOrHeroSelected => method_2<bool>("m_challengeeDeckOrHeroSelected");

		public bool m_challengerInGameState => method_2<bool>("m_challengerInGameState");

		public bool m_challengeeInGameState => method_2<bool>("m_challengeeInGameState");

		public DialogBase m_challengeDialog => method_3<DialogBase>("m_challengeDialog");

		public bool m_hasSeenDeclinedReason => method_2<bool>("m_hasSeenDeclinedReason");

		public bool m_updatePartyQuestInfoOnGameplaySceneUnload => method_2<bool>("m_updatePartyQuestInfoOnGameplaySceneUnload");

		public static string ATTRIBUTE_STATE_PLAYER1 => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_STATE_PLAYER1");

		public static string ATTRIBUTE_STATE_PLAYER2 => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_STATE_PLAYER2");

		public static string ATTRIBUTE_DECK_PLAYER1 => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_DECK_PLAYER1");

		public static string ATTRIBUTE_DECK_PLAYER2 => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_DECK_PLAYER2");

		public static string ATTRIBUTE_HERO_PLAYER1 => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_HERO_PLAYER1");

		public static string ATTRIBUTE_HERO_PLAYER2 => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_HERO_PLAYER2");

		public static string ATTRIBUTE_FSG_SHARED_SECRET_KEY_PLAYER1 => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_FSG_SHARED_SECRET_KEY_PLAYER1");

		public static string ATTRIBUTE_FSG_SHARED_SECRET_KEY_PLAYER2 => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_FSG_SHARED_SECRET_KEY_PLAYER2");

		public static string ATTRIBUTE_LEFT => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_LEFT");

		public static string ATTRIBUTE_ERROR => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_ERROR");

		public static string ATTRIBUTE_QUEST_INFO => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_QUEST_INFO");

		public static string ATTRIBUTE_VALUE_STATE_WAIT => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_VALUE_STATE_WAIT");

		public static string ATTRIBUTE_VALUE_STATE_WAIT_FOR_DECK_OR_HERO_SELECT => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_VALUE_STATE_WAIT_FOR_DECK_OR_HERO_SELECT");

		public static string ATTRIBUTE_VALUE_STATE_READY => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_VALUE_STATE_READY");

		public static string ATTRIBUTE_VALUE_STATE_GAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_VALUE_STATE_GAME");

		public static string ATTRIBUTE_VALUE_STATE_GOTO => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ATTRIBUTE_VALUE_STATE_GOTO");

		public FriendChallengeMgr(IntPtr address, string className)
			: base(address, className)
		{
		}

		public FriendChallengeMgr(IntPtr address)
			: this(address, "FriendChallengeMgr")
		{
		}

		public static FriendChallengeMgr Get()
		{
			return MonoClass.smethod_15<FriendChallengeMgr>(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "Get", Array.Empty<object>());
		}

		public static void ShowChallengerNeedsToCreateTavernBrawlDeckAlert()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "FriendChallengeMgr", "ShowChallengerNeedsToCreateTavernBrawlDeckAlert");
		}

		public void OnLoggedIn()
		{
			method_8("OnLoggedIn");
		}

		public void UpdatePartyQuestInfo()
		{
			method_8("UpdatePartyQuestInfo");
		}

		public void OnStoreOpened()
		{
			method_8("OnStoreOpened");
		}

		public void OnStoreClosed()
		{
			method_8("OnStoreClosed");
		}

		public BnetPlayer GetChallengee()
		{
			return method_14<BnetPlayer>("GetChallengee", Array.Empty<object>());
		}

		public BnetPlayer GetChallenger()
		{
			return method_14<BnetPlayer>("GetChallenger", Array.Empty<object>());
		}

		public bool DidReceiveChallenge()
		{
			return method_11<bool>("DidReceiveChallenge", Array.Empty<object>());
		}

		public bool DidSendChallenge()
		{
			return method_11<bool>("DidSendChallenge", Array.Empty<object>());
		}

		public bool HasChallenge()
		{
			return method_11<bool>("HasChallenge", Array.Empty<object>());
		}

		public bool AmIInGameState()
		{
			return method_11<bool>("AmIInGameState", Array.Empty<object>());
		}

		public BnetPlayer GetOpponent(BnetPlayer player)
		{
			return method_14<BnetPlayer>("GetOpponent", new object[1] { player });
		}

		public BnetPlayer GetMyOpponent()
		{
			return method_14<BnetPlayer>("GetMyOpponent", Array.Empty<object>());
		}

		public bool CanChallenge(BnetPlayer player)
		{
			return method_11<bool>("CanChallenge", new object[1] { player });
		}

		public bool AmIAvailable()
		{
			return method_11<bool>("AmIAvailable", Array.Empty<object>());
		}

		public bool DidISelectDeckOrHero()
		{
			return method_11<bool>("DidISelectDeckOrHero", Array.Empty<object>());
		}

		public bool DidOpponentSelectDeckOrHero()
		{
			return method_11<bool>("DidOpponentSelectDeckOrHero", Array.Empty<object>());
		}

		public void SendTavernBrawlChallenge(BnetPlayer player, BrawlType brawlType, int seasonId)
		{
			method_8("SendTavernBrawlChallenge", player, brawlType, seasonId);
		}

		public void TavernBrawl_SendChallenge_OnEnsureServerDataReady(BnetPlayer player, BrawlType brawlType, int seasonId)
		{
			method_8("TavernBrawl_SendChallenge_OnEnsureServerDataReady", player, brawlType, seasonId);
		}

		public void CancelChallenge()
		{
			method_8("CancelChallenge");
		}

		public void AcceptChallenge()
		{
			method_8("AcceptChallenge");
		}

		public void DeclineChallenge()
		{
			method_8("DeclineChallenge");
		}

		public void RescindChallenge()
		{
			method_8("RescindChallenge");
		}

		public bool IsChallengeStandardDuel()
		{
			return method_11<bool>("IsChallengeStandardDuel", Array.Empty<object>());
		}

		public bool IsChallengeWildDuel()
		{
			return method_11<bool>("IsChallengeWildDuel", Array.Empty<object>());
		}

		public bool IsChallengeTavernBrawl()
		{
			return method_11<bool>("IsChallengeTavernBrawl", Array.Empty<object>());
		}

		public bool IsChallengeFiresideBrawl()
		{
			return method_11<bool>("IsChallengeFiresideBrawl", Array.Empty<object>());
		}

		public BrawlType GetChallengeBrawlType()
		{
			return method_11<BrawlType>("GetChallengeBrawlType", Array.Empty<object>());
		}

		public void SkipDeckSelection()
		{
			method_8("SkipDeckSelection");
		}

		public void SelectDeck(long deckId)
		{
			method_8("SelectDeck", deckId);
		}

		public void SelectDeckBeforeSendingChallenge(long deckId)
		{
			method_8("SelectDeckBeforeSendingChallenge", deckId);
		}

		public void SelectHero(long heroCardDbId)
		{
			method_8("SelectHero", heroCardDbId);
		}

		public void SelectHeroBeforeSendingChallenge(long heroCardDbId)
		{
			method_8("SelectHeroBeforeSendingChallenge", heroCardDbId);
		}

		public void DeselectDeckOrHero()
		{
			method_8("DeselectDeckOrHero");
		}

		public void SelectMyDeck_InternalParty(long deckId)
		{
			method_8("SelectMyDeck_InternalParty", deckId);
		}

		public void SelectMyHero_InternalParty(long heroCardDbId)
		{
			method_8("SelectMyHero_InternalParty", heroCardDbId);
		}

		public int GetScenarioId()
		{
			return method_11<int>("GetScenarioId", Array.Empty<object>());
		}

		public bool PlayersInSameFiresideGathering()
		{
			return method_11<bool>("PlayersInSameFiresideGathering", Array.Empty<object>());
		}

		public void StartFriendlyChallengeGameIfReady()
		{
			method_8("StartFriendlyChallengeGameIfReady");
		}

		public void SetIAmInGameState()
		{
			method_8("SetIAmInGameState");
		}

		public void OnNetCacheReady()
		{
			method_8("OnNetCacheReady");
		}

		public void OnSceneUnloaded(SceneMgr.Mode prevMode, PegasusScene prevScene, object userData)
		{
			method_8("OnSceneUnloaded", prevMode, prevScene, userData);
		}

		public void OnSceneLoaded(SceneMgr.Mode mode, PegasusScene scene, object userData)
		{
			method_8("OnSceneLoaded", mode, scene, userData);
		}

		public void OnPlayersChanged(BnetPlayerChangelist changelist, object userData)
		{
			method_8("OnPlayersChanged", changelist, userData);
		}

		public void OnFriendsChanged(BnetFriendChangelist changelist, object userData)
		{
			method_8("OnFriendsChanged", changelist, userData);
		}

		public void OnNearbyPlayersChanged(BnetNearbyPlayerChangelist changelist, object userData)
		{
			method_8("OnNearbyPlayersChanged", changelist, userData);
		}

		public void OnChallengeChanged(FriendChallengeEvent challengeEvent, BnetPlayer player, object userData)
		{
			method_8("OnChallengeChanged", challengeEvent, player, userData);
		}

		public bool CanPromptReceivedChallenge()
		{
			return method_11<bool>("CanPromptReceivedChallenge", Array.Empty<object>());
		}

		public void CanPromptReceivedChallenge_OnDeckContentsLoaded()
		{
			method_8("CanPromptReceivedChallenge_OnDeckContentsLoaded");
		}

		public void TavernBrawl_ReceivedChallenge_OnEnsureServerDataReady()
		{
			method_8("TavernBrawl_ReceivedChallenge_OnEnsureServerDataReady");
		}

		public bool RevertTavernBrawlStatus()
		{
			return method_11<bool>("RevertTavernBrawlStatus", Array.Empty<object>());
		}

		public bool OnFindGameEvent(FindGameEventData eventData, object userData)
		{
			return method_11<bool>("OnFindGameEvent", new object[2] { eventData, userData });
		}

		public void WillReset()
		{
			method_8("WillReset");
		}

		public void ShowISentChallengeDialog(BnetPlayer challengee)
		{
			method_8("ShowISentChallengeDialog", challengee);
		}

		public void ShowOpponentDeclinedChallengeDialog(BnetPlayer challengee)
		{
			method_8("ShowOpponentDeclinedChallengeDialog", challengee);
		}

		public void ShowIReceivedChallengeDialog(BnetPlayer challenger)
		{
			method_8("ShowIReceivedChallengeDialog", challenger);
		}

		public void ShowOpponentCanceledChallengeDialog(BnetPlayer otherPlayer)
		{
			method_8("ShowOpponentCanceledChallengeDialog", otherPlayer);
		}

		public void ShowOpponentRemovedFromFriendsDialog(BnetPlayer otherPlayer)
		{
			method_8("ShowOpponentRemovedFromFriendsDialog", otherPlayer);
		}

		public bool OnChallengeSentDialogProcessed(DialogBase dialog, object userData)
		{
			return method_11<bool>("OnChallengeSentDialogProcessed", new object[2] { dialog, userData });
		}

		public void UpdateChallengeSentDialog()
		{
			method_8("UpdateChallengeSentDialog");
		}

		public void OnChallengeSentDialogResponse(AlertPopup.Response response, object userData)
		{
			method_8("OnChallengeSentDialogResponse", response, userData);
		}

		public bool OnChallengeReceivedDialogProcessed(DialogBase dialog, object userData)
		{
			return method_11<bool>("OnChallengeReceivedDialogProcessed", new object[2] { dialog, userData });
		}

		public void OnChallengeReceivedDialogResponse(bool accept)
		{
			method_8("OnChallengeReceivedDialogResponse", accept);
		}

		public void ResolveChallengeConflict()
		{
			method_8("ResolveChallengeConflict");
		}

		public void UpdateMyAvailability()
		{
			method_8("UpdateMyAvailability");
		}

		public bool HasAvailabilityBlocker()
		{
			return method_11<bool>("HasAvailabilityBlocker", Array.Empty<object>());
		}

		public AvailabilityBlockerReasons GetAvailabilityBlockerReason()
		{
			return method_11<AvailabilityBlockerReasons>("GetAvailabilityBlockerReason", Array.Empty<object>());
		}

		public void FireChangedEvent(FriendChallengeEvent challengeEvent, BnetPlayer player)
		{
			method_8("FireChangedEvent", challengeEvent, player);
		}

		public void CleanUpChallengeData(bool updateAvailability)
		{
			method_8("CleanUpChallengeData", updateAvailability);
		}

		public void StartChallengeProcess()
		{
			method_8("StartChallengeProcess");
		}
	}
}
